home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 001a / gtbimod.zip / GTBIMOD.C next >
Text File  |  1989-12-10  |  15KB  |  609 lines
  1. /*
  2. **
  3. *
  4.          Copyright (C)  P&M Software Co 1989.  All rights reserved
  5.  
  6.       THIS PROGRAM BELONGS TO P&M SOFTWARE CO.  IT IS CONSIDERED A TRADE
  7.       SECRET AND IS NOT TO BE DIVULGED OR USED BY PARTIES WHO HAVE NOT
  8.       RECEIVED WRITTEN AUTHORIZATION FROM THE OWNER.
  9.  
  10. *
  11. **
  12. */
  13.  
  14. /*
  15. **
  16. *
  17.               Uses TINY memory model.
  18. *
  19. **
  20. */
  21. #include <stdio.h>
  22. #include <fcntl.h>
  23. #include <stdlib.h>
  24. #include <string.h>
  25. #include <io.h>
  26. #include <errno.h>
  27. #include <sys\stat.h>
  28. #include <dos.h>
  29. #include <conio.h>
  30. #include <bios.h>
  31.  
  32. extern unsigned _heaplen  = 4096;
  33. extern unsigned _stklen   = 6144;
  34. extern int directvideo    = 0;
  35.  
  36. #define SIN_BUF_SIZE   1024
  37. #define SOUT_BUF_SIZE  1024
  38.  
  39. typedef struct bimod_time_lim {
  40.     char bi_hundreds;
  41.     char bi_seconds;
  42.     char bi_minutes;
  43.     char bi_hours;
  44. } BI_TIME_RECORD;
  45.  
  46. void prt_error(char *,char *);
  47. int o_mode(int);
  48. int skipper(char *,int);
  49. int sfopen(char *,int);
  50. int setup_bimodem(void);
  51. void main(int,char *[]);
  52.  
  53. static char bipath[80];
  54. static char bi_cfg[80];
  55. static char bi_mode[32];
  56. static char bi_xmit_pth[80];
  57. static char bi_recv_pth[80];
  58. static char bi_name[80];
  59. static char twoway_bbs[32];
  60. static char gws[4096];
  61. static unsigned int ramt;
  62. static BI_TIME_RECORD bi_time;
  63. static unsigned int pc_com_addr[] = { 0x03f8, 0x02f8, 0x03e8, 0x02e8 };
  64. static unsigned int pc_irq_asg[]  = {      4,      3,      4,      3 };
  65. static int com_port;
  66. static unsigned long baud_rate;
  67. static unsigned char sin_buffer[SIN_BUF_SIZE];
  68. static int sin_store_ptr;
  69. static int sin_read_ptr;
  70. static unsigned char sout_buffer[SOUT_BUF_SIZE];
  71. static int sout_store_ptr;
  72. static int sout_read_ptr;
  73. static unsigned char turn_irq_on;
  74. static unsigned char turn_irq_off;
  75. static int xmit_busy;
  76. static unsigned long irq_vector_addr;
  77. static unsigned long hold_vector;
  78. static int carrier_status = 1;
  79. static unsigned int base_com_addr;
  80. static unsigned int int_enable_reg;
  81. static unsigned int int_enable;
  82. static unsigned int int_ident_reg;
  83. static unsigned int line_control_reg;
  84. static unsigned int modem_control_reg;
  85. static unsigned int modem_control;
  86. static unsigned int line_status_reg;
  87. static unsigned int modem_status_reg;
  88. static unsigned char far *machine_id;
  89.  
  90. char read_sin_buffer()
  91. {
  92.     register char function;
  93.  
  94.     function = sin_buffer[sin_read_ptr];
  95.     if (++sin_read_ptr == SIN_BUF_SIZE)
  96.     sin_read_ptr = 0;
  97.     return(function);
  98. }
  99.  
  100. char *incom()
  101. {
  102.     static char incom_return[2];
  103.  
  104.     if (sin_store_ptr == sin_read_ptr)
  105.     return(NULL);
  106.     incom_return[0] = read_sin_buffer();
  107.     incom_return[1] = 0;
  108.     return(incom_return);
  109. }
  110.  
  111. int isDCD()
  112. {
  113.     return((inportb(modem_status_reg) & 0x0080));
  114. }
  115.  
  116. int iscarrier()
  117. {
  118.     register int res;
  119.  
  120.     res = 1;
  121.     if (! isDCD()) {
  122.         if (carrier_status)
  123.             delay(10);
  124.         if (! isDCD())
  125.             res = 0;
  126.     }
  127.     return((carrier_status = res));
  128. }
  129.  
  130. void store_sout_buffer(ch)
  131. char ch;
  132. {
  133.     sout_buffer[sout_store_ptr++] = ch;
  134.     if (sout_store_ptr == SOUT_BUF_SIZE)
  135.     sout_store_ptr = 0;
  136.     if (xmit_busy)
  137.     return;
  138.     disable();
  139.     if (xmit_busy)
  140.     goto L1soutx;
  141.     xmit_busy = 1;
  142.     outportb(base_com_addr,(int) sout_buffer[sout_read_ptr]);
  143.     if (++sout_read_ptr == SOUT_BUF_SIZE)
  144.     sout_read_ptr = 0;
  145. L1soutx:
  146.     enable();
  147. }
  148.  
  149. void send_str(s)
  150. char *s;
  151. {
  152.     register int i, j;
  153.  
  154.     i = 0;
  155.     while (j = s[i++]) {
  156.         store_sout_buffer(j);
  157.     putch(j);
  158.     iscarrier();
  159.     if (! carrier_status)
  160.         return;
  161.         delay(5);
  162.     }
  163. }
  164.  
  165. void set_int_vector(vaddr,value)
  166. unsigned long vaddr;
  167. unsigned long value;
  168. {
  169.     disable();
  170.     *((unsigned long far *) vaddr) = value;
  171.     enable();
  172. }
  173.  
  174. unsigned long get_int_vector(vaddr)
  175. unsigned long vaddr;
  176. {
  177.     unsigned long result;
  178.  
  179.     disable();
  180.     result = *((unsigned long far *) vaddr);
  181.     enable();
  182.     return(result);
  183. }
  184.  
  185. void reset_modem_vectors()
  186. {
  187.     disable();
  188.     int_enable = inportb(int_enable_reg);
  189.     outportb(int_enable_reg,(int_enable & 0xf0));
  190.     outportb(0x21,(inportb(0x21) | turn_irq_off));
  191.     enable();
  192.     set_int_vector(irq_vector_addr,hold_vector);
  193. }
  194.  
  195. void interrupt far async_intr_handler()
  196. {
  197. L1loop1:
  198.     switch (inportb(int_ident_reg)) {
  199.         case 1:
  200.             goto L1iret;
  201.         case 2:
  202. L1loop2:
  203.             if (sout_store_ptr == sout_read_ptr)
  204.                 xmit_busy = 0;
  205.             else {
  206.                 outportb(base_com_addr,(int) sout_buffer[sout_read_ptr]);
  207.                 sout_read_ptr++;
  208.                 if (sout_read_ptr == SOUT_BUF_SIZE)
  209.             sout_read_ptr = 0;
  210.                 xmit_busy = 1;
  211.             }
  212.             goto L1loop1;
  213.     case 12:
  214.         case  4:
  215.             sin_buffer[sin_store_ptr] = (char) inportb(base_com_addr);
  216.             sin_store_ptr++;
  217.             if (sin_store_ptr == SIN_BUF_SIZE)
  218.         sin_store_ptr = 0;
  219.             goto L1loop1;
  220.         case 0:
  221.             inportb(modem_status_reg);
  222.             goto L1rsx;
  223.         case 6:
  224.             inportb(line_status_reg);
  225.             break;
  226.         default:
  227.             inportb(modem_status_reg);
  228.             inportb(line_status_reg);
  229.             break;
  230.     }
  231.     goto L1loop1;
  232. L1rsx:
  233.     if (xmit_busy)
  234.         goto L1loop1;
  235.     goto L1loop2;
  236. L1iret:
  237.     outportb(0x20,0x20);
  238. }
  239.  
  240. #define pcjr 253
  241.  
  242. void setserial(baud)
  243. unsigned long baud;
  244. {
  245.     static int divs[] = {384, 192, 96, 48, 24, 12, 6, 3, 1};
  246.     int parameter;
  247.     int baudrate;
  248.     int stopbits, databits;
  249.     union REGS regs;
  250.  
  251.     baudrate = 4;
  252.     if (baud == 300)     baudrate = 2;
  253.     if (baud == 1200)    baudrate = 4;
  254.     if (baud == 2400)    baudrate = 5;
  255.     if (baud == 4800)    baudrate = 6;
  256.     if (baud == 9600)    baudrate = 7;
  257.     if (baud == 19200L)  baudrate = 8;
  258.     if (baud == 38400L)  baudrate = 9;
  259.     if (baud == 115200L) baudrate = 10;
  260.     stopbits = 0;            /* Default to 1 stop bit */
  261.     databits = 3;            /* Default to 8 data bits */
  262.     parameter = (stopbits << 2) + databits;
  263.     int_enable = inportb(int_enable_reg);
  264.     outportb(int_enable_reg,(int_enable & 0xf0));
  265.     if (*machine_id == pcjr) {
  266.         parameter = parameter | ((baudrate << 5) & 0x00ff);
  267.         regs.x.dx = com_port - 1;
  268.         regs.x.ax = parameter;
  269.         int86(0x14,®s,®s);
  270.     }
  271.     else  {
  272.         outportb(line_control_reg,0x80);
  273.         baudrate -= 2;
  274.         outportb(int_enable_reg,((divs[baudrate] >> 8) & 0x00ff));
  275.         outportb(base_com_addr,(divs[baudrate] & 0x00ff));
  276.         outportb(line_control_reg,parameter);
  277.         inportb(modem_status_reg);
  278.     inportb(int_ident_reg);
  279.     inportb(base_com_addr);
  280.         inportb(line_status_reg);
  281.     }
  282.     outportb(int_ident_reg,0x0);
  283.     modem_control = inportb(modem_control_reg) & 0xef;
  284.     outportb(modem_control_reg,(modem_control | 0x0b));
  285.     disable();
  286.     outportb(0x21,(inportb(0x21) & turn_irq_on));
  287.     enable();
  288.     int_enable = inportb(int_enable_reg);
  289.     outportb(int_enable_reg,(int_enable | 0x0f));
  290.     delay(10);
  291. }
  292.  
  293. void initialize_com_port()
  294. {
  295.     typedef int com_tab[4];
  296.     register int cp, irq;
  297.  
  298.     cp = com_port - 1;
  299.     machine_id = (char far *) 0xF000FFFEL;
  300.     if (*machine_id == pcjr)
  301.         base_com_addr = (*((com_tab *) 0x00000400))[cp];
  302.     else
  303.         base_com_addr = pc_com_addr[cp];
  304.     cp = 0;
  305.     while (base_com_addr != pc_com_addr[cp])
  306.     cp++;
  307.     irq = pc_irq_asg[cp];
  308.     turn_irq_off = (0x01 << irq);
  309.     turn_irq_on  = (turn_irq_off ^ 0xff);
  310.     irq_vector_addr = (unsigned long) (0x20 + (4 * irq));
  311.     sin_store_ptr =
  312.      sin_read_ptr =
  313.       sout_store_ptr =
  314.        sout_read_ptr = 0;
  315.     int_enable_reg = base_com_addr + 1;
  316.     int_ident_reg = int_enable_reg + 1;
  317.     line_control_reg = int_ident_reg + 1;
  318.     modem_control_reg = line_control_reg + 1;
  319.     line_status_reg = modem_control_reg + 1;
  320.     modem_status_reg = line_status_reg + 1;
  321.  
  322.     hold_vector = get_int_vector(irq_vector_addr);
  323.     set_int_vector(irq_vector_addr,(unsigned long) async_intr_handler);
  324.     setserial(baud_rate);
  325. }
  326.  
  327. void prt_error(fs,ns)
  328. char *fs;
  329. char *ns;
  330. {
  331.     perror("\nGTBIMOD");
  332.     printf(fs,ns);
  333.     sleep(2);
  334. }
  335.  
  336. int o_mode(omd)
  337. int omd;
  338. {
  339.     register int md;
  340.  
  341.     md = omd;
  342.     if (_osmajor > 2)
  343.     md = (md | O_DENYNONE);
  344.     return(md);
  345. }
  346.  
  347. int skipper(jstr,jo)
  348. char *jstr;
  349. int jo;
  350. {
  351.    while ((jo < ramt) && (jstr[jo]) && (jstr[jo] <= ' '))
  352.        jo++;
  353.    return(jo);
  354. }
  355.  
  356. int sfopen(fname,omode)
  357. char *fname;
  358. int omode;
  359. {
  360.     register int handle, loop;
  361.     char buf[80];
  362.  
  363.     loop = handle = (-1);
  364.     while (handle < 0) {
  365.     if ((handle = _open(fname,o_mode(omode))) < 0) {
  366.             if ((++loop >= 10) || (errno != EACCES)) {
  367.             sprintf(buf,"%s%s","Unable to open: ",fname);
  368.         prt_error("SFOPEN: %s",buf);
  369.             return(-1);
  370.         }
  371.             sleep(1);
  372.     }
  373.     }
  374.     return(handle);
  375. }
  376.  
  377. void extract(ds,j)
  378. char *ds;
  379. int *j;
  380. {
  381.     register int k, jp;
  382.  
  383.     jp = *j;
  384.     k  = 0;
  385.     while ((jp < ramt) && (gws[jp] > ' '))
  386.         ds[k++] = gws[jp++];
  387.     *j = skipper(gws,jp);
  388. }
  389.  
  390. int setup_bimodem()
  391. {
  392.     int jp, cfg, twoway, tim, result, lpth;
  393.     char logpath[96], ws[128];
  394.  
  395.     result = 0;
  396.     sprintf(bi_cfg,"%sBIMODEM.CFG",bipath);
  397.     strupr(bi_cfg);
  398.     if ((cfg = sfopen(bi_cfg,O_RDWR)) < 0)
  399.         return(1);
  400.     strcpy(twoway_bbs,"TWOWAY.BBS");
  401.     if ((twoway = sfopen(twoway_bbs,O_RDWR)) < 0) {
  402.     _close(cfg);
  403.         return(1);
  404.     }
  405.     memset((void *) gws,0,sizeof(gws));
  406.     lseek(twoway,0L,SEEK_SET);
  407.     ramt = _read(twoway,(void *) gws,(sizeof(gws)-16));
  408.     memset((void *) logpath,0x20,sizeof(logpath));
  409.     lseek(twoway,0L,SEEK_SET);
  410.     lpth = sprintf(logpath,"L %sBIMODEM.LOG\r\n",bipath);
  411.     _write(twoway,(void *) logpath,lpth);
  412.     _close(twoway);
  413.     memset((void *) bi_mode,0,sizeof(bi_mode));
  414.     memset((void *) bi_xmit_pth,0x20,sizeof(bi_xmit_pth));
  415.     memset((void *) bi_recv_pth,0x20,sizeof(bi_recv_pth));
  416.     jp = 0;
  417.     extract(bi_mode,    &jp);
  418.     extract(bi_xmit_pth,&jp);
  419.     extract(bi_recv_pth,&jp);
  420.     bi_mode[4] = 0;
  421.     tim = 120;
  422.     if (! strcmp(bi_mode,"TERM")) {
  423.         result = 2;
  424.     tim = 720;
  425.     }
  426.     if (! strcmp(bi_mode,"MAIL"))
  427.     result = 4;
  428.     if (! strcmp(bi_mode,"HOST")) {
  429.         result = 3;
  430.         tim = atoi(&bi_mode[5]);
  431.     }
  432.     printf("\nMODE = %s",bi_mode);
  433.     memmove((void *) ws,(void *) bi_xmit_pth,50);
  434.     ws[50] = 0;
  435.     printf("\nXMIT = %s",ws);
  436.     memmove((void *) ws,(void *) bi_recv_pth,50);
  437.     ws[50] = 0;
  438.     printf("\nRECV = %s\n",ws);
  439.     printf("\nTIME = %d",tim);
  440.     bi_time.bi_hundreds = 0;
  441.     bi_time.bi_seconds  = 0;
  442.     bi_time.bi_minutes  = (char) (tim % 60);
  443.     bi_time.bi_hours    = (char) (tim / 60);
  444.     lseek(cfg,0L,SEEK_SET);
  445.     _write(cfg,(void *) &bi_time,4);
  446.     lseek(cfg,37L,SEEK_SET);
  447.     _read(cfg,(void *) ws,16);
  448.     ws[0] |= 0x60;
  449.     lseek(cfg,37L,SEEK_SET);
  450.     _write(cfg,(void *) ws,16);
  451.     lseek(cfg,41L,SEEK_SET);
  452.     _write(cfg,(void *) bi_xmit_pth,80);
  453.     _write(cfg,(void *) bi_recv_pth,80);
  454.     logpath[lpth--] = 0x20;
  455.     logpath[lpth--] = 0x20;
  456.     logpath[lpth]   = 0x20;
  457.     _write(cfg,(void *) &logpath[2],80);
  458.     _close(cfg);
  459.     sprintf(ws,"DEL %sBIMODEM.LOG",bipath);
  460.     system(ws);
  461.  
  462.     sprintf(bi_cfg,"%sBIMODEM.PTH",bipath);
  463.     strupr(bi_cfg);
  464.     if (result == 3) {
  465.         sprintf(ws,"DEL %s",bi_cfg);
  466.         system(ws);
  467.     }
  468.     if (result == 4) {
  469.     memset((void *) bi_recv_pth,0x20,sizeof(bi_recv_pth));
  470.         if ((cfg = _creat(bi_cfg,0)) < 0)
  471.             return(1);
  472.         while (jp < ramt) {
  473.             memset((void *) bi_name,0x20,sizeof(bi_name));
  474.         extract(bi_name,&jp);
  475.         _write(cfg,(void *) "U       ",8);
  476.         _write(cfg,(void *) bi_name,80);
  477.         _write(cfg,(void *) bi_recv_pth,80);
  478.         _write(cfg,(void *) bi_recv_pth,80);
  479.     }
  480.     _close(cfg);
  481.     }
  482.     return(result);
  483. }
  484.  
  485. int keytest()
  486. {
  487.     return(bioskey(1));
  488. }
  489.  
  490. int keyread()
  491. {
  492.     return((bioskey(0) & 0x00FF));
  493. }
  494.  
  495. void main(argc,argv)
  496. int argc;
  497. char *argv[];
  498. {
  499.     register int j, loop;
  500.     unsigned int lcnt, ticks;
  501.     int rescode, pcnt, pa;
  502.     char *p;
  503.     char prior;
  504.  
  505.     directvideo = 0;
  506.     rescode = 1;
  507.     delay(0);
  508.     if (argc < 4) {
  509.         printf(  "\nGTBIMOD usage: gtbimod port baud bipath\\");
  510.         printf("\n\n    Where: 'port' ...... x:yyyy:z");
  511.     printf(  "\n                                 x = COM port #");
  512.     printf(  "\n                              yyyy = COM port addr");
  513.     printf(  "\n                                 z = IRQ #");
  514.     printf(  "\n           'baud' ...... is the current baud rate");
  515.     printf(  "\n           'bipath\\' ... points to a directory containing these files:");
  516.     printf("\n\n                 1.  BIMODEM.CFG");
  517.     printf(  "\n                 2.  BIMODEM.LOG");
  518.     printf(  "\n                 3.  BIMODEM.PTH");
  519.     printf(  "\n");
  520.         exit(1);
  521.     }
  522.     printf("PORT = %s\nBAUD = %s\nPATH = %s\n",argv[1],argv[2],argv[3]);
  523.     com_port = argv[1][0] - '0';
  524.     j = com_port - 1;
  525.     if (argv[1][1] == ':') {
  526.         sscanf(&argv[1][2],"%x",&pa);
  527.         pc_com_addr[j] = pa;
  528.     if (argv[1][6] == ':')
  529.             pc_irq_asg[j] = argv[1][7] - '0';
  530.     }
  531.     baud_rate = atol(argv[2]);
  532.     initialize_com_port();
  533.     strcpy(bipath,argv[3]);
  534.     j = strlen(bipath);
  535.     if (bipath[(j - 1)] != '\\') {
  536.         bipath[j++] = '\\';
  537.         bipath[j] = 0;
  538.     }
  539.     strupr(bipath);
  540.     iscarrier();
  541.     if (carrier_status) {
  542.         if ((rescode = setup_bimodem()) == 3) {
  543.         loop = iscarrier();
  544.         if (! loop)
  545.         rescode = 1;
  546.         send_str("\r\n\nThe HOST is ready.   Press ENTER when you are ready: ");
  547.         pcnt =
  548.          prior =
  549.           lcnt =
  550.            ticks = 0;
  551.             while (loop) {
  552.         if (++lcnt > 100) {
  553.             lcnt = 0;
  554.             if (++ticks > 55000U) {
  555.             send_str("\r\n\nTimeout...\r\n\n");
  556.             loop = 0;
  557.             rescode = 1;
  558.             }
  559.             delay(10);
  560.         }
  561.                 p = incom();
  562.         if (p != NULL) {
  563.             store_sout_buffer(p[0]);
  564.             putch(p[0]);
  565.             if (p[0] == 13) {
  566.             send_str("\n\n");
  567.             loop = 0;
  568.             }
  569.             else {
  570.             if (((p[0] == ' ') && (prior == 8)) || ((p[0] == 8) && (prior == ' '))) {
  571.                     if (pcnt++ > 1)
  572.                 loop = 0;
  573.             }
  574.             }
  575.             prior = p[0];
  576.         }
  577.         else {
  578.             if (keytest()) {
  579.             if ((keyread()) == 13) {
  580.                 send_str("\n\n");
  581.                 loop = 0;
  582.             }
  583.             }
  584.         }
  585.         iscarrier();
  586.         if (! carrier_status) {
  587.             loop = 0;
  588.             rescode = 1;
  589.         }
  590.         }
  591.     }
  592.     }
  593.     reset_modem_vectors();
  594.     exit(rescode);
  595. }
  596.  
  597. /*
  598. **
  599. *
  600.          Copyright (C)  P&M Software Co 1989.  All rights reserved
  601.  
  602.       THIS PROGRAM BELONGS TO P&M SOFTWARE CO.  IT IS CONSIDERED A TRADE
  603.       SECRET AND IS NOT TO BE DIVULGED OR USED BY PARTIES WHO HAVE NOT
  604.       RECEIVED WRITTEN AUTHORIZATION FROM THE OWNER.
  605.  
  606. *
  607. **
  608. */
  609.